home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / autoconf / m4sugar / m4sh.m4 next >
Text File  |  2006-04-25  |  34KB  |  1,128 lines
  1. # This file is part of Autoconf.                          -*- Autoconf -*-
  2. # M4 sugar for common shell constructs.
  3. # Requires GNU M4 and M4sugar.
  4. # Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2, or (at your option)
  9. # any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19. # 02111-1307, USA.
  20. #
  21. # As a special exception, the Free Software Foundation gives unlimited
  22. # permission to copy, distribute and modify the configure scripts that
  23. # are the output of Autoconf.  You need not follow the terms of the GNU
  24. # General Public License when using or distributing such scripts, even
  25. # though portions of the text of Autoconf appear in them.  The GNU
  26. # General Public License (GPL) does govern all other use of the material
  27. # that constitutes the Autoconf program.
  28. #
  29. # Certain portions of the Autoconf source text are designed to be copied
  30. # (in certain cases, depending on the input) into the output of
  31. # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  32. # source text consists of comments plus executable code that decides which
  33. # of the data portions to output in any given case.  We call these
  34. # comments and executable code the "non-data" portions.  Autoconf never
  35. # copies any of the non-data portions into its output.
  36. #
  37. # This special exception to the GPL applies to versions of Autoconf
  38. # released by the Free Software Foundation.  When you make and
  39. # distribute a modified version of Autoconf, you may extend this special
  40. # exception to the GPL to apply to your modified version as well, *unless*
  41. # your modified version has the potential to copy into its output some
  42. # of the text that was the non-data portion of the version that you started
  43. # with.  (In other words, unless your change moves or copies text from
  44. # the non-data portions to the data portions.)  If your modification has
  45. # such potential, you must delete any notice of this special exception
  46. # to the GPL from your modified version.
  47. #
  48. # Written by Akim Demaille, Pavel Roskin, Alexandre Oliva, Lars J. Aas
  49. # and many other people.
  50.  
  51.  
  52. # We heavily use m4's diversions both for the initializations and for
  53. # required macros, because in both cases we have to issue soon in
  54. # output something which is discovered late.
  55. #
  56. #
  57. # KILL is only used to suppress output.
  58. #
  59. # - BINSH
  60. #   AC_REQUIRE'd #! /bin/sh line
  61. # - HEADER-REVISION
  62. #   RCS keywords etc.
  63. # - HEADER-COMMENT
  64. #   Purpose of the script etc.
  65. # - HEADER-COPYRIGHT
  66. #   Copyright notice(s)
  67. # - M4SH-INIT
  68. #   M4sh's initializations
  69. #
  70. # - BODY
  71. #   The body of the script.
  72.  
  73.  
  74. # _m4_divert(DIVERSION-NAME)
  75. # --------------------------
  76. # Convert a diversion name into its number.  Otherwise, return
  77. # DIVERSION-NAME which is supposed to be an actual diversion number.
  78. # Of course it would be nicer to use m4_case here, instead of zillions
  79. # of little macros, but it then takes twice longer to run `autoconf'!
  80. m4_define([_m4_divert(BINSH)],             0)
  81. m4_define([_m4_divert(HEADER-REVISION)],   1)
  82. m4_define([_m4_divert(HEADER-COMMENT)],    2)
  83. m4_define([_m4_divert(HEADER-COPYRIGHT)],  3)
  84. m4_define([_m4_divert(M4SH-INIT)],         4)
  85. m4_define([_m4_divert(BODY)],           1000)
  86.  
  87. # Aaarg.  Yet it starts with compatibility issues...  Libtool wants to
  88. # use NOTICE to insert its own LIBTOOL-INIT stuff.  People should ask
  89. # before diving into our internals :(
  90. m4_copy([_m4_divert(M4SH-INIT)], [_m4_divert(NOTICE)])
  91.  
  92.  
  93.  
  94. ## ------------------------- ##
  95. ## 1. Sanitizing the shell.  ##
  96. ## ------------------------- ##
  97.  
  98.  
  99. # AS_REQUIRE(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK])
  100. # -----------------------------------------------------------
  101. # BODY-TO-EXPAND is some initialization which must be expanded in the
  102. # M4SH-INIT section when expanded (required or not).  This is very
  103. # different from m4_require.  For instance:
  104. #
  105. #      m4_defun([_FOO_PREPARE], [foo=foo])
  106. #      m4_defun([FOO],
  107. #      [m4_require([_FOO_PREPARE])dnl
  108. #      echo $foo])
  109. #
  110. #      m4_defun([_BAR_PREPARE], [bar=bar])
  111. #      m4_defun([BAR],
  112. #      [AS_REQUIRE([_BAR_PREPARE])dnl
  113. #      echo $bar])
  114. #
  115. #      AS_INIT
  116. #      foo1=`FOO`
  117. #      foo2=`FOO`
  118. #      bar1=`BAR`
  119. #      bar2=`BAR`
  120. #
  121. # gives
  122. #
  123. #      #! /bin/sh
  124. #      bar=bar
  125. #
  126. #      foo1=`foo=foo
  127. #      echo $foo`
  128. #      foo2=`echo $foo`
  129. #      bar1=`echo $bar`
  130. #      bar2=`echo $bar`
  131. #
  132. m4_define([AS_REQUIRE],
  133. [m4_provide_if([$1], [],
  134.            [m4_divert_text([M4SH-INIT], [m4_default([$2], [$1])])])])
  135.  
  136.  
  137. # AS_SHELL_SANITIZE
  138. # -----------------
  139. # Try to be as Bourne and/or POSIX as possible.
  140. m4_defun([AS_SHELL_SANITIZE],
  141. [## --------------------- ##
  142. ## M4sh Initialization.  ##
  143. ## --------------------- ##
  144.  
  145. # Be Bourne compatible
  146. if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  147.   emulate sh
  148.   NULLCMD=:
  149.   [#] Zsh 3.x and 4.x performs word splitting on ${1+"$[@]"}, which
  150.   # is contrary to our usage.  Disable this feature.
  151.   alias -g '${1+"$[@]"}'='"$[@]"'
  152. elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  153.   set -o posix
  154. fi
  155. DUALCASE=1; export DUALCASE # for MKS sh
  156.  
  157. _AS_UNSET_PREPARE
  158.  
  159. # Work around bugs in pre-3.0 UWIN ksh.
  160. $as_unset ENV MAIL MAILPATH
  161. PS1='$ '
  162. PS2='> '
  163. PS4='+ '
  164.  
  165. # NLS nuisances.
  166. for as_var in \
  167.   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  168.   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  169.   LC_TELEPHONE LC_TIME
  170. do
  171.   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  172.     eval $as_var=C; export $as_var
  173.   else
  174.     $as_unset $as_var
  175.   fi
  176. done
  177.  
  178. # Required to use basename.
  179. _AS_EXPR_PREPARE
  180. _AS_BASENAME_PREPARE
  181.  
  182. # Name of the executable.
  183. as_me=`AS_BASENAME("$[0]")`
  184.  
  185. ])
  186.  
  187.  
  188. # _AS_PREPARE
  189. # -----------
  190. # This macro has a very special status.  Normal use of M4sh relies
  191. # heavily on AS_REQUIRE, so that needed initializations (such as
  192. # _AS_TEST_PREPARE) are performed on need, not on demand.  But
  193. # Autoconf is the first client of M4sh, and for two reasons: configure
  194. # and config.status.  Relying on AS_REQUIRE is of course fine for
  195. # configure, but fails for config.status (which is created by
  196. # configure).  So we need a means to force the inclusion of the
  197. # various _AS_PREPARE_* on top of config.status.  That's basically why
  198. # there are so many _AS_PREPARE_* below, and that's also why it is
  199. # important not to forget some: config.status needs them.
  200. m4_defun([_AS_PREPARE],
  201. [# PATH needs CR, and LINENO needs CR and PATH.
  202. _AS_CR_PREPARE
  203. _AS_PATH_SEPARATOR_PREPARE
  204. _AS_LINENO_PREPARE
  205.  
  206. _AS_ECHO_N_PREPARE
  207. _AS_EXPR_PREPARE
  208. _AS_LN_S_PREPARE
  209. _AS_MKDIR_P_PREPARE
  210. _AS_TEST_PREPARE
  211. _AS_TR_CPP_PREPARE
  212. _AS_TR_SH_PREPARE
  213.  
  214. # IFS
  215. # We need space, tab and new line, in precisely that order.
  216. as_nl='
  217. '
  218. IFS="     $as_nl"
  219.  
  220. # CDPATH.
  221. $as_unset CDPATH
  222. ])
  223.  
  224.  
  225. # AS_PREPARE
  226. # ----------
  227. # Output all the M4sh possible initialization into the initialization
  228. # diversion.
  229. m4_defun([AS_PREPARE],
  230. [m4_divert_text([M4SH-INIT], [_AS_PREPARE])])
  231.  
  232.  
  233. ## ----------------------------- ##
  234. ## 2. Wrappers around builtins.  ##
  235. ## ----------------------------- ##
  236.  
  237. # This section is lexicographically sorted.
  238.  
  239.  
  240. # AS_EXIT([EXIT-CODE = 1])
  241. # ------------------------
  242. # Exit and set exit code to EXIT-CODE in the way that it's seen
  243. # within "trap 0".
  244. #
  245. # We cannot simply use "exit N" because some shells (zsh and Solaris sh)
  246. # will not set $? to N while running the code set by "trap 0"
  247. # So we set $? by executing "exit N" in the subshell and then exit.
  248. # Other shells don't use `$?' as default for `exit', hence just repeating
  249. # the exit value can only help improving portability.
  250. m4_define([AS_EXIT],
  251. [{ (exit m4_default([$1], 1)); exit m4_default([$1], 1); }])
  252.  
  253.  
  254. # AS_IF(TEST, [IF-TRUE], [IF-FALSE])
  255. # ----------------------------------
  256. # Expand into
  257. # | if TEST; then
  258. # |   IF-TRUE
  259. # | else
  260. # |   IF-FALSE
  261. # | fi
  262. # with simplifications is IF-TRUE and/or IF-FALSE is empty.
  263. #
  264. # FIXME: Be n-ary, just as m4_if.
  265. m4_define([AS_IF],
  266. [m4_ifval([$2$3],
  267. [if $1; then
  268.   m4_ifval([$2], [$2], :)
  269. m4_ifvaln([$3],
  270. [else
  271.   $3])dnl
  272. fi
  273. ])dnl
  274. ])# AS_IF
  275.  
  276.  
  277. # _AS_UNSET_PREPARE
  278. # -----------------
  279. # AS_UNSET depends upon $as_unset: compute it.
  280. # Use MAIL to trigger a bug in Bash 2.01;
  281. # the "|| exit" suppresses the resulting "Segmentation fault" message.
  282. # Avoid 'if ((', as that triggers a bug in pdksh 5.2.14.
  283. m4_defun([_AS_UNSET_PREPARE],
  284. [# Support unset when possible.
  285. if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  286.   as_unset=unset
  287. else
  288.   as_unset=false
  289. fi
  290. ])
  291.  
  292.  
  293. # AS_UNSET(VAR, [VALUE-IF-UNSET-NOT-SUPPORTED = `'])
  294. # --------------------------------------------------
  295. # Try to unset the env VAR, otherwise set it to
  296. # VALUE-IF-UNSET-NOT-SUPPORTED.  `as_unset' must have been computed.
  297. m4_defun([AS_UNSET],
  298. [AS_REQUIRE([_AS_UNSET_PREPARE])dnl
  299. $as_unset $1 || test "${$1+set}" != set || { $1=$2; export $1; }])
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306. ## ------------------------------------------ ##
  307. ## 3. Error and warnings at the shell level.  ##
  308. ## ------------------------------------------ ##
  309.  
  310. # If AS_MESSAGE_LOG_FD is defined, shell messages are duplicated there
  311. # too.
  312.  
  313.  
  314. # AS_ESCAPE(STRING, [CHARS = $"'\])
  315. # ---------------------------------
  316. # Escape the CHARS in STRING.
  317. m4_define([AS_ESCAPE],
  318. [m4_bpatsubst([$1],
  319.          m4_ifval([$2], [[\([$2]\)]], [[\([\"$`]\)]]),
  320.          [\\\1])])
  321.  
  322.  
  323. # _AS_QUOTE_IFELSE(STRING, IF-MODERN-QUOTATION, IF-OLD-QUOTATION)
  324. # ---------------------------------------------------------------
  325. # Compatibility glue between the old AS_MSG suite which did not
  326. # quote anything, and the modern suite which quotes the quotes.
  327. # If STRING contains `\\' or `\$', it's modern.
  328. # If STRING contains `\"' or `\`', it's old.
  329. # Otherwise it's modern.
  330. # We use two quotes in the pattern to keep highlighting tools at peace.
  331. m4_define([_AS_QUOTE_IFELSE],
  332. [m4_bmatch([$1],
  333.       [\\[\\$]], [$2],
  334.       [\\[`""]], [$3],
  335.       [$2])])
  336.  
  337.  
  338. # _AS_ECHO_UNQUOTED(STRING, [FD = AS_MESSAGE_FD])
  339. # -----------------------------------------------
  340. # Perform shell expansions on STRING and echo the string to FD.
  341. m4_define([_AS_ECHO_UNQUOTED],
  342. [echo "$1" >&m4_default([$2], [AS_MESSAGE_FD])])
  343.  
  344.  
  345. # _AS_QUOTE(STRING, [CHARS = `"])
  346. # -------------------------------
  347. # If there are quoted (via backslash) backquotes do nothing, else
  348. # backslash all the quotes.
  349. m4_define([_AS_QUOTE],
  350. [_AS_QUOTE_IFELSE([$1],
  351.           [AS_ESCAPE([$1], m4_default([$2], [`""]))],
  352.           [m4_warn([obsolete],
  353.        [back quotes and double quotes must not be escaped in: $1])dnl
  354. $1])])
  355.  
  356.  
  357. # _AS_ECHO(STRING, [FD = AS_MESSAGE_FD])
  358. # --------------------------------------
  359. # Protect STRING from backquote expansion, echo the result to FD.
  360. m4_define([_AS_ECHO],
  361. [_AS_ECHO_UNQUOTED([_AS_QUOTE([$1])], [$2])])
  362.  
  363.  
  364. # _AS_ECHO_N_PREPARE
  365. # ------------------
  366. # Check whether to use -n, \c, or newline-tab to separate
  367. # checking messages from result messages.
  368. # Don't try to cache, since the results of this macro are needed to
  369. # display the checking message.  In addition, caching something used once
  370. # has little interest.
  371. # Idea borrowed from dist 3.0.  Use `*c*,', not `*c,' because if `\c'
  372. # failed there is also a new-line to match.
  373. m4_defun([_AS_ECHO_N_PREPARE],
  374. [case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
  375.   *c*,-n*) ECHO_N= ECHO_C='
  376. ' ECHO_T='    ' ;;
  377.   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
  378.   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
  379. esac
  380. ])# _AS_ECHO_N_PREPARE
  381.  
  382.  
  383. # _AS_ECHO_N(STRING, [FD = AS_MESSAGE_FD])
  384. # ----------------------------------------
  385. # Same as _AS_ECHO, but echo doesn't return to a new line.
  386. m4_define([_AS_ECHO_N],
  387. [AS_REQUIRE([_AS_ECHO_N_PREPARE])dnl
  388. echo $ECHO_N "_AS_QUOTE([$1])$ECHO_C" >&m4_default([$2],
  389.                             [AS_MESSAGE_FD])])
  390.  
  391.  
  392. # AS_MESSAGE(STRING, [FD = AS_MESSAGE_FD])
  393. # ----------------------------------------
  394. m4_define([AS_MESSAGE],
  395. [m4_ifset([AS_MESSAGE_LOG_FD],
  396.       [{ _AS_ECHO([$as_me:$LINENO: $1], [AS_MESSAGE_LOG_FD])
  397. _AS_ECHO([$as_me: $1], [$2]);}],
  398.       [_AS_ECHO([$as_me: $1], [$2])])[]dnl
  399. ])
  400.  
  401.  
  402. # AS_WARN(PROBLEM)
  403. # ----------------
  404. m4_define([AS_WARN],
  405. [AS_MESSAGE([WARNING: $1], [2])])# AS_WARN
  406.  
  407.  
  408. # AS_ERROR(ERROR, [EXIT-STATUS = 1])
  409. # ----------------------------------
  410. m4_define([AS_ERROR],
  411. [{ AS_MESSAGE([error: $1], [2])
  412.    AS_EXIT([$2]); }[]dnl
  413. ])# AS_ERROR
  414.  
  415.  
  416.  
  417. ## -------------------------------------- ##
  418. ## 4. Portable versions of common tools.  ##
  419. ## -------------------------------------- ##
  420.  
  421. # This section is lexicographically sorted.
  422.  
  423.  
  424. # AS_DIRNAME(PATHNAME)
  425. # --------------------
  426. # Simulate running `dirname(1)' on PATHNAME, not all systems have it.
  427. # This macro must be usable from inside ` `.
  428. #
  429. # Prefer expr to echo|sed, since expr is usually faster and it handles
  430. # backslashes and newlines correctly.  However, older expr
  431. # implementations (e.g. SunOS 4 expr and Solaris 8 /usr/ucb/expr) have
  432. # a silly length limit that causes expr to fail if the matched
  433. # substring is longer than 120 bytes.  So fall back on echo|sed if
  434. # expr fails.
  435. m4_defun([AS_DIRNAME_EXPR],
  436. [AS_REQUIRE([_AS_EXPR_PREPARE])dnl
  437. $as_expr X[]$1 : 'X\(.*[[^/]]\)//*[[^/][^/]]*/*$' \| \
  438.      X[]$1 : 'X\(//\)[[^/]]' \| \
  439.      X[]$1 : 'X\(//\)$' \| \
  440.      X[]$1 : 'X\(/\)' \| \
  441.      .     : '\(.\)'])
  442.  
  443. m4_defun([AS_DIRNAME_SED],
  444. [echo X[]$1 |
  445.     sed ['/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
  446.         /^X\(\/\/\)[^/].*/{ s//\1/; q; }
  447.         /^X\(\/\/\)$/{ s//\1/; q; }
  448.         /^X\(\/\).*/{ s//\1/; q; }
  449.         s/.*/./; q']])
  450.  
  451. m4_defun([AS_DIRNAME],
  452. [(dirname $1) 2>/dev/null ||
  453. AS_DIRNAME_EXPR([$1]) 2>/dev/null ||
  454. AS_DIRNAME_SED([$1])])
  455.  
  456.  
  457. # AS_BASENAME(PATHNAME)
  458. # --------------------
  459. # Simulate running `basename(1)' on PATHNAME, not all systems have it.
  460. # Also see the comments for AS_DIRNAME.
  461.  
  462. m4_defun([AS_BASENAME_EXPR],
  463. [AS_REQUIRE([_AS_EXPR_PREPARE])dnl
  464. $as_expr X/[]$1 : '.*/\([[^/][^/]*]\)/*$' \| \
  465.      X[]$1 : 'X\(//\)$' \| \
  466.      X[]$1 : 'X\(/\)$' \| \
  467.      .     : '\(.\)'])
  468.  
  469. m4_defun([AS_BASENAME_SED],
  470. [echo X/[]$1 |
  471.     sed ['/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  472.         /^X\/\(\/\/\)$/{ s//\1/; q; }
  473.         /^X\/\(\/\).*/{ s//\1/; q; }
  474.         s/.*/./; q']])
  475.  
  476. m4_defun([AS_BASENAME],
  477. [AS_REQUIRE([_$0_PREPARE])dnl
  478. $as_basename $1 ||
  479. AS_BASENAME_EXPR([$1]) 2>/dev/null ||
  480. AS_BASENAME_SED([$1])])
  481.  
  482.  
  483. # AS_EXECUTABLE_P
  484. # ---------------
  485. # Check whether a file is executable.
  486. m4_defun([AS_EXECUTABLE_P],
  487. [AS_REQUIRE([_AS_TEST_PREPARE])dnl
  488. $as_executable_p $1[]dnl
  489. ])# AS_EXECUTABLE_P
  490.  
  491.  
  492. # _AS_BASENAME_PREPARE
  493. # --------------------
  494. # Avoid Solaris 9 /usr/ucb/basename, as `basename /' outputs an empty line.
  495. m4_defun([_AS_BASENAME_PREPARE],
  496. [if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  497.   as_basename=basename
  498. else
  499.   as_basename=false
  500. fi
  501. ])# _AS_BASENAME_PREPARE
  502.  
  503. # _AS_EXPR_PREPARE
  504. # ----------------
  505. # Some expr work properly (i.e. compute and issue the right result),
  506. # but exit with failure.  When a fall back to expr (as in AS_DIRNAME)
  507. # is provided, you get twice the result.  Prevent this.
  508. m4_defun([_AS_EXPR_PREPARE],
  509. [if expr a : '\(a\)' >/dev/null 2>&1; then
  510.   as_expr=expr
  511. else
  512.   as_expr=false
  513. fi
  514. ])# _AS_EXPR_PREPARE
  515.  
  516. # _AS_LINENO_WORKS
  517. # ---------------
  518. # Succeed if the currently executing shell supports LINENO.
  519. # This macro does not expand to a single shell command, so be careful
  520. # when using it.  Surrounding the body of this macro with {} would
  521. # cause "bash -c '_ASLINENO_WORKS'" to fail (with Bash 2.05, anyway),
  522. # but that bug is irrelevant to our use of LINENO.
  523. m4_define([_AS_LINENO_WORKS],
  524. [
  525.   as_lineno_1=$LINENO
  526.   as_lineno_2=$LINENO
  527.   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
  528.   test "x$as_lineno_1" != "x$as_lineno_2" &&
  529.   test "x$as_lineno_3"  = "x$as_lineno_2" dnl
  530. ])
  531.  
  532. # _AS_LINENO_PREPARE
  533. # ------------------
  534. # If LINENO is not supported by the shell, produce a version of this
  535. # script where LINENO is hard coded.
  536. # Comparing LINENO against _oline_ is not a good solution, since in
  537. # the case of embedded executables (such as config.status within
  538. # configure) you'd compare LINENO wrt config.status vs. _oline_ vs
  539. # configure.
  540. m4_define([_AS_LINENO_PREPARE],
  541. [AS_REQUIRE([_AS_CR_PREPARE])dnl
  542. _AS_LINENO_WORKS || {
  543.   # Find who we are.  Look in the path if we contain no path at all
  544.   # relative or not.
  545.   case $[0] in
  546.     *[[\\/]]* ) as_myself=$[0] ;;
  547.     *) _AS_PATH_WALK([],
  548.            [test -r "$as_dir/$[0]" && as_myself=$as_dir/$[0] && break])
  549.        ;;
  550.   esac
  551.   # We did not find ourselves, most probably we were run as `sh COMMAND'
  552.   # in which case we are not to be found in the path.
  553.   if test "x$as_myself" = x; then
  554.     as_myself=$[0]
  555.   fi
  556.   if test ! -f "$as_myself"; then
  557.     AS_ERROR([cannot find myself; rerun with an absolute path])
  558.   fi
  559.   case $CONFIG_SHELL in
  560.   '')
  561.     _AS_PATH_WALK([/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH],
  562.       [for as_base in sh bash ksh sh5; do
  563.      case $as_dir in
  564.      /*)
  565.        if ("$as_dir/$as_base" -c '_AS_LINENO_WORKS') 2>/dev/null; then
  566.          AS_UNSET(BASH_ENV)
  567.          AS_UNSET(ENV)
  568.          CONFIG_SHELL=$as_dir/$as_base
  569.          export CONFIG_SHELL
  570.          exec "$CONFIG_SHELL" "$[0]" ${1+"$[@]"}
  571.        fi;;
  572.      esac
  573.        done]);;
  574.   esac
  575.  
  576.   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
  577.   # uniformly replaced by the line number.  The first 'sed' inserts a
  578.   # line-number line before each line; the second 'sed' does the real
  579.   # work.  The second script uses 'N' to pair each line-number line
  580.   # with the numbered line, and appends trailing '-' during
  581.   # substitution so that $LINENO is not a special case at line end.
  582.   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
  583.   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
  584.   sed '=' <$as_myself |
  585.     sed '
  586.       N
  587.       s,$,-,
  588.       : loop
  589.       s,^\([['$as_cr_digits']]*\)\(.*\)[[$]]LINENO\([[^'$as_cr_alnum'_]]\),\1\2\1\3,
  590.       t loop
  591.       s,-$,,
  592.       s,^[['$as_cr_digits']]*\n,,
  593.     ' >$as_me.lineno &&
  594.   chmod +x $as_me.lineno ||
  595.     AS_ERROR([cannot create $as_me.lineno; rerun with a POSIX shell])
  596.  
  597.   # Don't try to exec as it changes $[0], causing all sort of problems
  598.   # (the dirname of $[0] is not the place where we might find the
  599.   # original and so on.  Autoconf is especially sensible to this).
  600.   . ./$as_me.lineno
  601.   # Exit status is that of the last command.
  602.   exit
  603. }
  604. ])# _AS_LINENO_PREPARE
  605.  
  606.  
  607. # _AS_LN_S_PREPARE
  608. # ----------------
  609. # Don't use conftest.sym to avoid filename issues on DJGPP, where this
  610. # would yield conftest.sym.exe for DJGPP < 2.04.  And don't use `conftest'
  611. # as base name to avoid prohibiting concurrency (e.g., concurrent
  612. # config.statuses).
  613. m4_defun([_AS_LN_S_PREPARE],
  614. [rm -f conf$$ conf$$.exe conf$$.file
  615. echo >conf$$.file
  616. if ln -s conf$$.file conf$$ 2>/dev/null; then
  617.   # We could just check for DJGPP; but this test a) works b) is more generic
  618.   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
  619.   if test -f conf$$.exe; then
  620.     # Don't use ln at all; we don't have any links
  621.     as_ln_s='cp -p'
  622.   else
  623.     as_ln_s='ln -s'
  624.   fi
  625. elif ln conf$$.file conf$$ 2>/dev/null; then
  626.   as_ln_s=ln
  627. else
  628.   as_ln_s='cp -p'
  629. fi
  630. rm -f conf$$ conf$$.exe conf$$.file
  631. ])# _AS_LN_S_PREPARE
  632.  
  633.  
  634. # _AS_PATH_SEPARATOR_PREPARE
  635. # --------------------------
  636. # Compute the path separator.
  637. m4_defun([_AS_PATH_SEPARATOR_PREPARE],
  638. [# The user is always right.
  639. if test "${PATH_SEPARATOR+set}" != set; then
  640.   echo "#! /bin/sh" >conf$$.sh
  641.   echo  "exit 0"   >>conf$$.sh
  642.   chmod +x conf$$.sh
  643.   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  644.     PATH_SEPARATOR=';'
  645.   else
  646.     PATH_SEPARATOR=:
  647.   fi
  648.   rm -f conf$$.sh
  649. fi
  650. ])# _AS_PATH_SEPARATOR_PREPARE
  651.  
  652.  
  653. # _AS_PATH_WALK([PATH = $PATH], BODY)
  654. # -----------------------------------
  655. # Walk through PATH running BODY for each `as_dir'.
  656. #
  657. # Still very private as its interface looks quite bad.
  658. #
  659. # `$as_dummy' forces splitting on constant user-supplied paths.
  660. # POSIX.2 field splitting is done only on the result of word
  661. # expansions, not on literal text.  This closes a longstanding sh security
  662. # hole.  Optimize it away when not needed, i.e., if there are no literal
  663. # path separators.
  664. m4_define([_AS_PATH_WALK],
  665. [AS_REQUIRE([_AS_PATH_SEPARATOR_PREPARE])dnl
  666. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  667. m4_bmatch([$1], [[:;]],
  668. [as_dummy="$1"
  669. for as_dir in $as_dummy],
  670. [for as_dir in m4_default([$1], [$PATH])])
  671. do
  672.   IFS=$as_save_IFS
  673.   test -z "$as_dir" && as_dir=.
  674.   $2
  675. done
  676. ])
  677.  
  678.  
  679. # AS_LN_S(FILE, LINK)
  680. # -------------------
  681. # FIXME: Should we add the glue code to handle properly relative symlinks
  682. # simulated with `ln' or `cp'?
  683. m4_defun([AS_LN_S],
  684. [AS_REQUIRE([_AS_LN_S_PREPARE])dnl
  685. $as_ln_s $1 $2
  686. ])
  687.  
  688.  
  689. # _AS_MKDIR_P_PREPARE
  690. # -------------------
  691. m4_defun([_AS_MKDIR_P_PREPARE],
  692. [if mkdir -p . 2>/dev/null; then
  693.   as_mkdir_p=:
  694. else
  695.   test -d ./-p && rmdir ./-p
  696.   as_mkdir_p=false
  697. fi
  698. ])# _AS_MKDIR_P_PREPARE
  699.  
  700. # AS_MKDIR_P(PATH)
  701. # ----------------
  702. # Emulate `mkdir -p' with plain `mkdir'.
  703. m4_define([AS_MKDIR_P],
  704. [AS_REQUIRE([_$0_PREPARE])dnl
  705. { if $as_mkdir_p; then
  706.     mkdir -p $1
  707.   else
  708.     as_dir=$1
  709.     as_dirs=
  710.     while test ! -d "$as_dir"; do
  711.       as_dirs="$as_dir $as_dirs"
  712.       as_dir=`AS_DIRNAME("$as_dir")`
  713.     done
  714.     test ! -n "$as_dirs" || mkdir $as_dirs
  715.   fi || AS_ERROR([cannot create directory $1]); }
  716. ])# AS_MKDIR_P
  717.  
  718.  
  719. # _AS_BROKEN_TEST_PREPARE
  720. # -----------------------
  721. # FIXME: This does not work and breaks way too many things.
  722. #
  723. # Find out ahead of time whether we want test -x (preferred) or test -f
  724. # to check whether a file is executable.
  725. m4_defun([_AS_BROKEN_TEST_PREPARE],
  726. [# Find out how to test for executable files. Don't use a zero-byte file,
  727. # as systems may use methods other than mode bits to determine executability.
  728. cat >conf$$.file <<_ASEOF
  729. @%:@! /bin/sh
  730. exit 0
  731. _ASEOF
  732. chmod +x conf$$.file
  733. if test -x conf$$.file >/dev/null 2>&1; then
  734.   as_executable_p="test -x"
  735. elif test -f conf$$.file >/dev/null 2>&1; then
  736.   as_executable_p="test -f"
  737. else
  738.   AS_ERROR([cannot check whether a file is executable on this system])
  739. fi
  740. rm -f conf$$.file
  741. ])# _AS_BROKEN_TEST_PREPARE
  742.  
  743.  
  744. # _AS_TEST_PREPARE
  745. # ----------------
  746. m4_defun([_AS_TEST_PREPARE],
  747. [as_executable_p="test -f"
  748. ])# _AS_BROKEN_TEST_PREPARE
  749.  
  750.  
  751. # AS_SET_CATFILE(VAR, DIR-NAME, FILE-NAME)
  752. # ----------------------------------------
  753. # Set VAR to DIR-NAME/FILE-NAME.
  754. # Optimize the common case where $2 or $3 is '.'.
  755. m4_define([AS_SET_CATFILE],
  756. [case $2 in
  757. .) $1=$3;;
  758. *)
  759.   case $3 in
  760.   .) $1=$2;;
  761.   [[\\/]]* | ?:[[\\/]]* ) $1=$3;;
  762.   *) $1=$2/$3;;
  763.   esac;;
  764. esac[]dnl
  765. ])# AS_SET_CATFILE
  766.  
  767.  
  768.  
  769.  
  770. ## ------------------ ##
  771. ## 5. Common idioms.  ##
  772. ## ------------------ ##
  773.  
  774. # This section is lexicographically sorted.
  775.  
  776.  
  777. # AS_BOX(MESSAGE, [FRAME-CHARACTER = `-'])
  778. # ----------------------------------------
  779. # Output MESSAGE, a single line text, framed with FRAME-CHARACTER (which
  780. # must not be `/').
  781. m4_define([AS_BOX],
  782. [AS_LITERAL_IF([$1],
  783.            [_AS_BOX_LITERAL($@)],
  784.            [_AS_BOX_INDIR($@)])])
  785.  
  786. # _AS_BOX_LITERAL(MESSAGE, [FRAME-CHARACTER = `-'])
  787. # -------------------------------------------------
  788. m4_define([_AS_BOX_LITERAL],
  789. [cat <<\_ASBOX
  790. m4_text_box($@)
  791. _ASBOX])
  792.  
  793. # _AS_BOX_INDIR(MESSAGE, [FRAME-CHARACTER = `-'])
  794. # -----------------------------------------------
  795. m4_define([_AS_BOX_INDIR],
  796. [sed 'h;s/./m4_default([$2], [-])/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX
  797. @%:@@%:@ $1 @%:@@%:@
  798. _ASBOX])
  799.  
  800.  
  801. # AS_LITERAL_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL)
  802. # -----------------------------------------------------
  803. # If EXPRESSION has shell indirections ($var or `expr`), expand
  804. # IF-INDIR, else IF-NOT-INDIR.
  805. # This is an *approximation*: for instance EXPRESSION = `\$' is
  806. # definitely a literal, but will not be recognized as such.
  807. m4_define([AS_LITERAL_IF],
  808. [m4_bmatch([$1], [[`$]],
  809.        [$3], [$2])])
  810.  
  811.  
  812. # AS_TMPDIR(PREFIX, [DIRECTORY = $TMPDIR [= /tmp]])
  813. # -------------------------------------------------
  814. # Create as safely as possible a temporary directory in DIRECTORY
  815. # which name is inspired by PREFIX (should be 2-4 chars max), and set
  816. # trap mechanisms to remove it.
  817. m4_define([AS_TMPDIR],
  818. [# Create a temporary directory, and hook for its removal unless debugging.
  819. $debug ||
  820. {
  821.   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
  822.   trap 'AS_EXIT([1])' 1 2 13 15
  823. }
  824.  
  825. # Create a (secure) tmp directory for tmp files.
  826. m4_if([$2], [], [: ${TMPDIR=/tmp}])
  827. {
  828.   tmp=`(umask 077 && mktemp -d -q "m4_default([$2], [$TMPDIR])/$1XXXXXX") 2>/dev/null` &&
  829.   test -n "$tmp" && test -d "$tmp"
  830. }  ||
  831. {
  832.   tmp=m4_default([$2], [$TMPDIR])/$1$$-$RANDOM
  833.   (umask 077 && mkdir $tmp)
  834. } ||
  835. {
  836.    echo "$me: cannot create a temporary directory in m4_default([$2], [$TMPDIR])" >&2
  837.    AS_EXIT
  838. }dnl
  839. ])# AS_TMPDIR
  840.  
  841.  
  842. # AS_UNAME
  843. # --------
  844. # Try to describe this machine.  Meant for logs.
  845. m4_define([AS_UNAME],
  846. [{
  847. cat <<_ASUNAME
  848. m4_text_box([Platform.])
  849.  
  850. hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
  851. uname -m = `(uname -m) 2>/dev/null || echo unknown`
  852. uname -r = `(uname -r) 2>/dev/null || echo unknown`
  853. uname -s = `(uname -s) 2>/dev/null || echo unknown`
  854. uname -v = `(uname -v) 2>/dev/null || echo unknown`
  855.  
  856. /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
  857. /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
  858.  
  859. /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
  860. /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
  861. /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
  862. hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
  863. /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
  864. /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
  865. /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
  866.  
  867. _ASUNAME
  868.  
  869. _AS_PATH_WALK([$PATH], [echo "PATH: $as_dir"])
  870. }])
  871.  
  872.  
  873. # AS_HELP_STRING(LHS, RHS, [COLUMN])
  874. # ----------------------------------
  875. #
  876. # Format a help string so that it looks pretty when
  877. # the user executes "script --help".  This macro takes three
  878. # arguments, a "left hand side" (LHS), a "right hand side" (RHS), and
  879. # the COLUMN which is a string of white spaces which leads to the
  880. # the RHS column (default: 26 white spaces).
  881. #
  882. # The resulting string is suitable for use in other macros that require
  883. # a help string (e.g. AC_ARG_WITH).
  884. #
  885. # Here is the sample string from the Autoconf manual (Node: External
  886. # Software) which shows the proper spacing for help strings.
  887. #
  888. #    --with-readline         support fancy command line editing
  889. #  ^ ^                       ^
  890. #  | |                       |
  891. #  | column 2                column 26
  892. #  |
  893. #  column 0
  894. #
  895. # A help string is made up of a "left hand side" (LHS) and a "right
  896. # hand side" (RHS).  In the example above, the LHS is
  897. # "--with-readline", while the RHS is "support fancy command line
  898. # editing".
  899. #
  900. # If the LHS is contains more than (COLUMN - 3) characters, then the LHS
  901. # is terminated with a newline so that the RHS starts on a line of its
  902. # own beginning with COLUMN.  In the default case, this corresponds to
  903. # an LHS with more than 23 characters.
  904. #
  905. # Therefore, in the example, if the LHS were instead
  906. # "--with-readline-blah-blah-blah", then the AS_HELP_STRING macro would
  907. # expand into:
  908. #
  909. #
  910. #    --with-readline-blah-blah-blah
  911. #  ^ ^                       support fancy command line editing
  912. #  | |                       ^
  913. #  | column 2                |
  914. #  column 0                  column 26
  915. #
  916. m4_define([AS_HELP_STRING],
  917. [m4_pushdef([AS_Prefix], m4_default([$3], [                          ]))dnl
  918. m4_pushdef([AS_Prefix_Format],
  919.        [  %-]m4_eval(m4_len(AS_Prefix) - 3)[s ])dnl [  %-23s ]
  920. m4_text_wrap([$2], AS_Prefix, m4_format(AS_Prefix_Format, [$1]))dnl
  921. m4_popdef([AS_Prefix_Format])dnl
  922. m4_popdef([AS_Prefix])dnl
  923. ])
  924.  
  925.  
  926.  
  927. ## ------------------------------------ ##
  928. ## Common m4/sh character translation.  ##
  929. ## ------------------------------------ ##
  930.  
  931. # The point of this section is to provide high level macros comparable
  932. # to m4's `translit' primitive, but m4/sh polymorphic.
  933. # Transliteration of literal strings should be handled by m4, while
  934. # shell variables' content will be translated at runtime (tr or sed).
  935.  
  936.  
  937. # _AS_CR_PREPARE
  938. # --------------
  939. # Output variables defining common character ranges.
  940. # See m4_cr_letters etc.
  941. m4_defun([_AS_CR_PREPARE],
  942. [# Avoid depending upon Character Ranges.
  943. as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  944. as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  945. as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  946. as_cr_digits='0123456789'
  947. as_cr_alnum=$as_cr_Letters$as_cr_digits
  948. ])
  949.  
  950.  
  951. # _AS_TR_SH_PREPARE
  952. # -----------------
  953. m4_defun([_AS_TR_SH_PREPARE],
  954. [AS_REQUIRE([_AS_CR_PREPARE])dnl
  955. # Sed expression to map a string onto a valid variable name.
  956. as_tr_sh="eval sed 'y%*+%pp%;s%[[^_$as_cr_alnum]]%_%g'"
  957. ])
  958.  
  959.  
  960. # AS_TR_SH(EXPRESSION)
  961. # --------------------
  962. # Transform EXPRESSION into a valid shell variable name.
  963. # sh/m4 polymorphic.
  964. # Be sure to update the definition of `$as_tr_sh' if you change this.
  965. m4_defun([AS_TR_SH],
  966. [AS_REQUIRE([_$0_PREPARE])dnl
  967. AS_LITERAL_IF([$1],
  968.           [m4_bpatsubst(m4_translit([[$1]], [*+], [pp]),
  969.                 [[^a-zA-Z0-9_]], [_])],
  970.           [`echo "$1" | $as_tr_sh`])])
  971.  
  972.  
  973. # _AS_TR_CPP_PREPARE
  974. # ------------------
  975. m4_defun([_AS_TR_CPP_PREPARE],
  976. [AS_REQUIRE([_AS_CR_PREPARE])dnl
  977. # Sed expression to map a string onto a valid CPP name.
  978. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[[^_$as_cr_alnum]]%_%g'"
  979. ])
  980.  
  981.  
  982. # AS_TR_CPP(EXPRESSION)
  983. # ---------------------
  984. # Map EXPRESSION to an upper case string which is valid as rhs for a
  985. # `#define'.  sh/m4 polymorphic.  Be sure to update the definition
  986. # of `$as_tr_cpp' if you change this.
  987. m4_defun([AS_TR_CPP],
  988. [AS_REQUIRE([_$0_PREPARE])dnl
  989. AS_LITERAL_IF([$1],
  990.           [m4_bpatsubst(m4_translit([[$1]],
  991.                     [*abcdefghijklmnopqrstuvwxyz],
  992.                     [PABCDEFGHIJKLMNOPQRSTUVWXYZ]),
  993.                [[^A-Z0-9_]], [_])],
  994.           [`echo "$1" | $as_tr_cpp`])])
  995.  
  996.  
  997. # _AS_TR_PREPARE
  998. # --------------
  999. m4_defun([_AS_TR_PREPARE],
  1000. [AS_REQUIRE([_AS_TR_SH_PREPARE])dnl
  1001. AS_REQUIRE([_AS_TR_CPP_PREPARE])dnl
  1002. ])
  1003.  
  1004.  
  1005.  
  1006.  
  1007. ## --------------------------------------------------- ##
  1008. ## Common m4/sh handling of variables (indirections).  ##
  1009. ## --------------------------------------------------- ##
  1010.  
  1011.  
  1012. # The purpose of this section is to provide a uniform API for
  1013. # reading/setting sh variables with or without indirection.
  1014. # Typically, one can write
  1015. #   AS_VAR_SET(var, val)
  1016. # or
  1017. #   AS_VAR_SET(as_$var, val)
  1018. # and expect the right thing to happen.
  1019.  
  1020.  
  1021. # AS_VAR_SET(VARIABLE, VALUE)
  1022. # ---------------------------
  1023. # Set the VALUE of the shell VARIABLE.
  1024. # If the variable contains indirections (e.g. `ac_cv_func_$ac_func')
  1025. # perform whenever possible at m4 level, otherwise sh level.
  1026. m4_define([AS_VAR_SET],
  1027. [AS_LITERAL_IF([$1],
  1028.            [$1=$2],
  1029.            [eval "$1=AS_ESCAPE([$2])"])])
  1030.  
  1031.  
  1032. # AS_VAR_GET(VARIABLE)
  1033. # --------------------
  1034. # Get the value of the shell VARIABLE.
  1035. # Evaluates to $VARIABLE if there are no indirection in VARIABLE,
  1036. # else into the appropriate `eval' sequence.
  1037. m4_define([AS_VAR_GET],
  1038. [AS_LITERAL_IF([$1],
  1039.            [$$1],
  1040.            [`eval echo '${'m4_bpatsubst($1, [[\\`]], [\\\&])'}'`])])
  1041.  
  1042.  
  1043. # AS_VAR_TEST_SET(VARIABLE)
  1044. # -------------------------
  1045. # Expands into the `test' expression which is true if VARIABLE
  1046. # is set.  Polymorphic.  Should be dnl'ed.
  1047. m4_define([AS_VAR_TEST_SET],
  1048. [AS_LITERAL_IF([$1],
  1049.            [test "${$1+set}" = set],
  1050.            [eval "test \"\${$1+set}\" = set"])])
  1051.  
  1052.  
  1053. # AS_VAR_SET_IF(VARIABLE, IF-TRUE, IF-FALSE)
  1054. # ------------------------------------------
  1055. # Implement a shell `if-then-else' depending whether VARIABLE is set
  1056. # or not.  Polymorphic.
  1057. m4_define([AS_VAR_SET_IF],
  1058. [AS_IF([AS_VAR_TEST_SET([$1])], [$2], [$3])])
  1059.  
  1060.  
  1061. # AS_VAR_PUSHDEF and AS_VAR_POPDEF
  1062. # --------------------------------
  1063. #
  1064.  
  1065. # Sometimes we may have to handle literals (e.g. `stdlib.h'), while at
  1066. # other moments, the same code may have to get the value from a
  1067. # variable (e.g., `ac_header').  To have a uniform handling of both
  1068. # cases, when a new value is about to be processed, declare a local
  1069. # variable, e.g.:
  1070. #
  1071. #   AS_VAR_PUSHDEF([header], [ac_cv_header_$1])
  1072. #
  1073. # and then in the body of the macro, use `header' as is.  It is of
  1074. # first importance to use `AS_VAR_*' to access this variable.  Don't
  1075. # quote its name: it must be used right away by m4.
  1076. #
  1077. # If the value `$1' was a literal (e.g. `stdlib.h'), then `header' is
  1078. # in fact the value `ac_cv_header_stdlib_h'.  If `$1' was indirect,
  1079. # then `header's value in m4 is in fact `$ac_header', the shell
  1080. # variable that holds all of the magic to get the expansion right.
  1081. #
  1082. # At the end of the block, free the variable with
  1083. #
  1084. #   AS_VAR_POPDEF([header])
  1085.  
  1086.  
  1087. # AS_VAR_PUSHDEF(VARNAME, VALUE)
  1088. # ------------------------------
  1089. # Define the m4 macro VARNAME to an accessor to the shell variable
  1090. # named VALUE.  VALUE does not need to be a valid shell variable name:
  1091. # the transliteration is handled here.  To be dnl'ed.
  1092. m4_define([AS_VAR_PUSHDEF],
  1093. [AS_LITERAL_IF([$2],
  1094.            [m4_pushdef([$1], [AS_TR_SH($2)])],
  1095.            [as_$1=AS_TR_SH($2)
  1096. m4_pushdef([$1], [$as_[$1]])])])
  1097.  
  1098.  
  1099. # AS_VAR_POPDEF(VARNAME)
  1100. # ----------------------
  1101. # Free the shell variable accessor VARNAME.  To be dnl'ed.
  1102. m4_define([AS_VAR_POPDEF],
  1103. [m4_popdef([$1])])
  1104.  
  1105.  
  1106.  
  1107. ## ----------------- ##
  1108. ## Setting M4sh up.  ##
  1109. ## ----------------- ##
  1110.  
  1111.  
  1112. # AS_INIT
  1113. # -------
  1114. m4_define([AS_INIT],
  1115. [m4_init
  1116.  
  1117. # Forbidden tokens and exceptions.
  1118. m4_pattern_forbid([^_?AS_])
  1119.  
  1120. # Bangshe and minimal initialization.
  1121. m4_divert_text([BINSH], [@%:@! /bin/sh])
  1122. m4_divert_text([M4SH-INIT], [AS_SHELL_SANITIZE])
  1123.  
  1124. # Let's go!
  1125. m4_wrap([m4_divert_pop([BODY])[]])
  1126. m4_divert_push([BODY])[]dnl
  1127. ])
  1128.